package com.hnas.common.util;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.Random;

import com.hnas.core.util.StringUtil;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public final class Util {
    private final static char[] HEX = { '0', '1', '2', '3', '4', '5', '6', '7',
            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    private Util() {
    }
	/**
	 * 测试使用的主函数
	 * @param args   命令行参数
	 */
	public static void main(String[] args) {
		try{
				String imageURL="D:\\images\\3333.jpg";
				String ss=ImageConverteStr(imageURL);
				String imageURL1="D:\\images\\4444.jpg";
				boolean bl= GenerateImage(ss,imageURL1);
				if(bl){
					System.out.println("生成图片成功");
				}else{
					System.out.println("生成图片失败");
				}
//				Random random = new Random();
//			    double ran = Math.random();
//			   if (ran <= 0.33) {  // 6 位
//			      System.out.println("6位:"+100000 + random.nextInt(900000));
//			   } else if ((ran > 0.33) && (ran < 0.67)) { // 7 位
//			       System.out.println("7位:"+1000000 + random.nextInt(9000000));
//			   } else { // 8 位
//			       System.out.println("8位:"+10000000 + random.nextInt(90000000));
//			    }
		}catch(Exception ex){
			
		}
//		//字符串转字节
//		String sendDataStr="7B7B68C2C72BB7540D9170DA200B92214664232941DC5CF5A1D292FEF5CF86CF456F0572F66281BD6F04B635AB9CFC2AAAF50EF560D0919F0A20E00004BC7D5322250D83D4F3931587E6647B12FF15835D7F8F495C26EBD4179B2A2597618C1A477AE7AE730BE70D0E30A12B1EDCFFCF645A92B3F235D4CBE3D66C408E2A832E46DD05055477F06194A8A9A1BB20826DD79B7554EA36D8580C14A0FE7B1AE81381140E81C0F9CBD6C7267D4C83B3CAEEA909D8BCED2B8E0C128DE5F07524FF949EC26E39B48DB414E451CD742D6E47CE61A5BC095B625ADC25B04BD05B5913E054118898318DF3484ED9C76B852BFEE45A3CA1371C6607E64AB2A3A169C062EC7E77C8186784026D639BE863A3A7EF3738E2BD73C8E6E066F9D3AC3734E45F1A7FFC75D5722196E36ACE85CE6635BC2D1C88EAC0004E4523A057153D8BD87A45153B1AA7A764A397CB3227B26235C6E9876DC0D56B8D47CB06AA83FB4FAD5691DF1840956C19332BE8AC8E5BC11C61B8122738EFF1EFC55A0D0A69EC767854AE528007D849B2DD32F70531938BBD23AA1F57F6489BCBE3F5CECFE14D1FA44ED9FD979683AFCDADA10BD84919EF9F515C80018C0CE0765131F458A3832DAD37D700B7FEFDC776C4FA4D316986525A0C591D37325FAB23E15BF88BC7772E5F47C086580FA79BACFB62D5EC5D49F7C7798E9C06212D06E3AB36AAE348C077C5A4C1";
//        byte[] recBuf=StringUtil.hexToByte(sendDataStr);  
//		 String receiveDataStr=Util.BCD2String(recBuf, 512);
//		 System.out.println("字节转字符串:"+receiveDataStr);
//		int ntest = 200;
//		byte val;
//		byte [] res = IntToHexStr(ntest);
//		val = res[0];
//		 //
//		byte[] val2 = new byte[] {0x11,(byte) 0xaa,(byte) 0xbb};
//		byte [] res2 =new byte[6];
//		HexToAscii(val2,res2,3);
//
//		byte[] val3 = new byte[]{'1','a','2','b'};
//		int res3 = HexStrToInt(val3,4);
	}
    /*将整型数据转换为HEX字节码
    如 :200转换为000000C8
    * */
    public static byte[] toBytes(int a) {
        return new byte[] { (byte) (0x000000ff & (a >>> 24)),
                (byte) (0x000000ff & (a >>> 16)),
                (byte) (0x000000ff & (a >>> 8)), (byte) (0x000000ff & (a)) };
    }    
     
     //************************************
	// 函数功能:  16进制数组值转为整型
	// 函数全名:  HexToInt
	// 作    者:  陶志高
	// 访问权限:  public 
	// 返回类型:  TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明:  char * pHex   如：0x1A2B,最多4字节
	// 参数说明:  int * intVal  转换后的int值6699
	// 参数说明:  int hexlen
	/*
    将b的startpos开始的连续nbytes字节转换为INT数据
    如：000000C8转换为200*/
	//************************************
    public static int toInt(byte[] b, int startpos, int nbytes) {
        int ret = 0;
        final int endpos = startpos + nbytes;
        for (int i = startpos; i < endpos; ++i) {
            ret <<= 8;
            ret |= b[i] & 0xFF;
        }
        return ret;
    }

    /*
    将b的startpos结束的连续nbytes字节转换为INT数据(b中的整型数据是高低字节倒序的)
    如：000000C8转换为200
     */
    public static int toIntR(byte[] b, int s, int n) {
        int ret = 0;
        for (int i = s; (i >= 0 && n > 0); --i, --n) {
            ret <<= 8;
            ret |= b[i] & 0xFF;
        }
        return ret;
    }

    /*
    * */
    public static int toInt(byte... b) {
        int ret = 0;
        for (final byte a : b) {
            ret <<= 8;
            ret |= a & 0xFF;
        }
        return ret;
    }

    /*
	    nbytes      d的长度
	    startpos    d中要转换为字符串的字节起始位置  start
     */
    public static String toHexString(byte[] d, int startpos, int nbytes) {
        final char[] ret = new char[nbytes * 2];
        final int endpos = startpos + nbytes;
        int x = 0;
        for (int i = startpos; i < endpos; ++i) {
            final byte v = d[i];
            ret[x++] = HEX[0x0F & (v >> 4)];
            ret[x++] = HEX[0x0F & v];
        }
        return new String(ret);
    }

    public static String toHexStringR(byte[] d, int s, int n) {
        final char[] ret = new char[n * 2];

        int x = 0;
        for (int i = s + n - 1; i >= s; --i) {
            final byte v = d[i];
            ret[x++] = HEX[0x0F & (v >> 4)];
            ret[x++] = HEX[0x0F & v];
        }
        return new String(ret);
    }

    public static int parseInt(String txt, int radix, int def) {
        int ret;
        try {
            ret = Integer.valueOf(txt, radix);
        } catch (Exception e) {
            ret = def;
        }
        return ret;
    }

    public static String toAmountString(float value) {
        return String.format("%.2f", value);
    }

    public static String toBcdCardno(String cardno){
        String cardnoafter = cardno.substring(8);
        while(cardnoafter.substring(0,1).equals("0")){
            cardnoafter = cardnoafter.substring(1);
        }
        String bcdcard = String.valueOf(Integer.parseInt(cardnoafter+"",16));
        while(bcdcard.length()<8){
            bcdcard="0"+bcdcard;
        }
        return cardno.substring(0,8)+bcdcard;
    }

    public static String toHexCardno(String cardno){
        String cardnoafter = cardno.substring(8);
        while(cardnoafter.substring(0,1).equals("0")){
            cardnoafter = cardnoafter.substring(1);
        }
        String bcdcard = String.valueOf(Integer.parseInt(cardnoafter+"",16));
        while(bcdcard.length()<8){
            bcdcard="0"+bcdcard;
        }
        return cardno.substring(0,8)+bcdcard;
    }
    /////////////////////////////////////////////////////////
    //************************************
	// 功    能:    16进制转换成字符串
	// 函 数 名:    bytesHexToString
	// 返 回 值:    string
	// 作    者：  陈清
	// 参    数:    byte[] data     要转换的十六进制数字节=
	//说明   "\x12\x34\x56\x78"->"12345678" 
	//************************************
    //16进制转换成字符串
    public static String bytesHexToString(byte[] data) {
        String tempHexStr = "";
        for (byte d : data) {
            tempHexStr += String.format("%02x", d);
        }
        return tempHexStr;
    }
	/**
	 * 16进制字符串转换成数组
	 * 
	 * @param hex
	 * @return
	 */
	public static byte[] hexStringTobyte(String hex) {
		if (StringUtil.isEmpty(hex)) {
			return null;
		}
		hex = hex.toUpperCase();
		int len = hex.length() / 2;
		byte[] result = new byte[len];
		char[] achar = hex.toCharArray();
		String temp = "";
		for (int i = 0; i < len; i++) {
			int pos = i * 2;
			result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
			temp += result[i] + ",";
		}
		// uiHandler.obtainMessage(206, hex + "=read=" + new String(result))
		// .sendToTarget();
		return result;
	}
	public static int toByte(char c) {
		byte b = (byte) "0123456789ABCDEF".indexOf(c);
		return b;
	}
    /////////////////////////////////////////////////////////
    //************************************
	// 功    能:    将一个十六进制字节串转换成 ASCII 码表示的字符串
	// 函 数 名:    HexToAscii
	// 返 回 值:    void
	// 作    者：   陶志高
	// 参    数:    unsigned char * pHex     要转换的十六进制数字节串首地址
	// 参    数:    unsigned char * pAscii   转换后的 ASCII 码表示的字符串的首地址
	// 参    数:    int nHexLen                 要转换的十六进制数的长度（字节数）
	//说明   不对数组越界进行检查 例: "\x12\x34\x56\x78"->"12345678" nHexLen=4 转换后8字节
	//************************************
    public static void HexToAscii(byte[] pHex, byte[] pAscii, int nHexLen)
    {
        byte curChar;
        for (int nChar = 0 ;nChar < nHexLen ; ++nChar)
        {
            //高四字节
            curChar = (byte) ((pHex[nChar] & 0xF0)>>4);
            if (curChar >= 0x00 && curChar <= 0x09)
            {
                //0-9
                pAscii[nChar*2] = (byte) (curChar + 0x30);
            }
            if (curChar >= 0x0A)
            {
                //A-F
                pAscii[nChar*2] = (byte) (curChar + 0x37);
            }
            //低四字节
            curChar = (byte) (pHex[nChar] & 0x0F);
            if (curChar >= 0x00 && curChar <= 0x09)
            {
                //0-9
                pAscii[nChar*2+1] = (byte) (curChar + 0x30);
            }
            if (curChar >= 0x0A)
            {
                //A-F
                pAscii[nChar*2+1] = (byte) (curChar + 0x37);
            }
        }
    }

    //************************************
	// 功    能:    将一个 ASCII 码表示的十六进制字符串转换成十六进制的字节串(值)
	// 函 数 名:    AsciiToHex
	// 返 回 值:    BOOL  不是0-9 A-F a-f返回FALSE
	// 作    者：   陶志高
	// 参    数:    unsigned char * pAscii  要转换的 ASCII 码表示的十六进制字符串的首地址
	// 参    数:    unsigned char * pHex    转换后的十六进制数字节串首地址
	// 参    数:    int nASCLen             要转换的 ASCII 码表示的十六进制字符串的长度（字节数）
	//说明：自动去掉空格，不对数组越界进行检查, 例  "12 34 5678"->"\x12\x34\x56\x78" nlen=8 转换后4字节
	//************************************
    public static boolean AsciiToHex(byte[] pAscii, byte[] pHex, int nASCLen)
    {
        byte curChar;
        int nHex = 0 , nSpace = 0;
        boolean bHight = false;
        for (int nChar = 0 ;nChar < nASCLen ; ++nChar)
        {
            //第N个字符
            curChar = pAscii[nChar];
            if (curChar == ' ')
            {
                //去掉空格
                ++nSpace;
                continue;
            }
            //对应的16进制数
            nHex = (nChar - nSpace)/2;
            bHight = (((nChar - nSpace)%2) == 1)?false:true;
            if (curChar >= '0' && curChar <= '9')
            {
                //0-9
                if (bHight)
                {
                    pHex[nHex] = (byte) ((curChar - 0x30)<<4);
                }
                else
                {
                    pHex[nHex] = (byte) (pHex[nHex] + curChar - 0x30);
                }
                continue;
            }
            if (curChar >= 'a' && curChar <= 'f')
            {
                //a-f
                if (bHight)
                {
                    pHex[nHex] = (byte) ((curChar - 0x57)<<4);
                }
                else
                {
                    pHex[nHex] = (byte) (pHex[nHex] + curChar - 0x57);
                }
                continue;
            }
            if (curChar >= 'A' && curChar <= 'F')
            {
                //A-F
                if (bHight)
                {
                    pHex[nHex] = (byte) ((curChar - 0x37)<<4);
                }
                else
                {
                    pHex[nHex] = (byte) (pHex[nHex] + curChar - 0x37);
                }
                continue;
            }
            return false;
        }
        return true;
    }

    //************************************
	// 函数功能:  16进制字符串转为整型
	// 函数全名:  HexStrToInt
	// 作    者:  陶志高
	// 访问权限:  public 
	// 返回类型:  TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明:  char * pHexStr  如：“1A2B”最多8个字符，4字节
	// 参数说明:  int * intVal    转换后的int值6699
	// 参数说明:  int hexlen      字符串长度
	//************************************
    public static int HexStrToInt(byte[] pHexStr , int hexlen)
    {
    	int  intVal = 0;
			byte[] pHex = new byte[4];
			if (!AsciiToHex(pHexStr,pHex,hexlen))
			{
				return 0;
			}
			intVal = toInt(pHex,0,hexlen/2);
			return intVal;
		}

    //************************************
	// 函数功能:  整型转为16进制数组
	// 函数全名:  IntToHex
	// 作    者:  陶志高
	// 访问权限:  public 
	// 返回类型:  TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明:  char * pHexSource  最多4字节,如：36转换后为0x00000024
	// 参数说明:  int  intVal  要转换的整数
	// 参数说明:  int* hexlen   转换后的HEX长度,总长度为4字节，hexlen为实际数据字节长度，如36转换后为0x00000024，hexlen＝1
	//************************************
    public static byte[] IntToHex(  int intVal)
    {
    	return toBytes(intVal);
    }

    //************************************
	// 函数功能:  整型转为16进制字符串
	// 函数全名:  IntToHexStr
	// 作    者:  陶志高
	// 访问权限:  public 
	// 返回类型:  TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明:  char * pHexStr   最多8字节,如：36转换后为0x00000024
	// 参数说明:  int  intVal   要转换的整数
	// 参数说明:  int * hexlen     转换后的HEX长度
	//************************************
    public static byte[] IntToHexStr( int intVal )
    {
			byte[] pHexStr = new byte[8];
			byte[] pHex = IntToHex(intVal);
			HexToAscii(pHex,pHexStr,4);
			return pHexStr;
	}
    
	
	//************************************
    // 0x12 0x34 0x56 -->123456 nHexLen=3 转换后6字节
    public static String BCD2String(byte[] bData,int nLength)
    {
    	byte[] retData=new byte[nLength*2];
    	HexToAscii(bData,retData,nLength);
    	return Byte2String(retData);
    }
    
    //123456    0x12 0x34 0x56 nlen=6 转换后3字节
    public static byte[] String2BCD(String strData,int nLength)
    {
    	byte[] inData=String2Byte(strData);
    	byte[] retData=new byte[nLength/2];
    	AsciiToHex(inData,retData,nLength);
    	return retData;
    }
    
    // 0x1A 0x1B 装换为6699 nlength=2     最长智能处理4个字节
    public static int HexToint(byte[] data,int nlength)
    {
    	String tmp=bytesHexToString(data);
    	byte[] tmp2=String2Byte(tmp);
    	int ret=0;
    	ret=HexStrToInt(tmp2,nlength);
    	return ret;
    }
    //把string以byte显示 123456  \x31\x32\x33\x34\x35\x36
    public static byte[] String2Byte(String data)
    {
    	byte[] sendBytes = null;
		try {
			sendBytes = data.getBytes("UTF8");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	return sendBytes;
    }
    //把byte以string显示 \x31\x32\x33\x34\x35\x36  123456  
    public static String Byte2String(byte[] data)
    {
    	String sendString = null;
		try {
			sendString = new String(data ,"UTF-8");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	return sendString;
    }
    //前补0
    public static byte[] fillZero(byte[] inData,int count)
    {
    	try 
    	{
	    	int nLength=inData.length;
	    	nLength=nLength+count;
	    	ByteBuffer buff = ByteBuffer.allocate(nLength);
	    	for(int i=0;i<count;i++)
	    	{
	    		buff.put((byte) 0x00);
	    	}	
		    buff.put(inData);//
			return buff.array();
    	}
    	 catch (Exception e) {
 			// TODO Auto-generated catch block
 			return null;
 		}
    }
    //short转成返回码的String 返回4字节的返回码String型
    public static String Short2String(short s)
    {
    	return BCD2String(getBytes(s,true),2);
    }
    //2字节的状态码的data转换成short
	public static short byte2short(byte[] data) {
		return (short) ((data[0] << 8) | (0xFF & data[1]));
	}
    //short 转byte[]
    public static byte[] getBytes(short s, boolean bBigEnding) {
    	  byte[] buf = new byte[2];
    	  if (bBigEnding)
    	   for (int i = buf.length - 1; i >= 0; i--) {
    	    buf[i] = (byte) (s & 0x00ff);
    	    s >>= 8;
    	   }
    	  else
    	   for (int i = 0; i < buf.length; i++) {
    	    buf[i] = (byte) (s & 0x00ff);
    	    s >>= 8;
    	   }
    	  return buf;
    	 }
    /**
     *  base64字符串生成图片
     * @param imgStr
     * @param imgFilePath
     * @return
     */
    public static boolean GenerateImage(String imgStr,String imgFilePath)
    { //对字节数组字符串进行Base64解码并生成图片
        if (imgStr == null || null == imgFilePath){
        	   return false;//图像数据为空
        }
        try
        {
        	BASE64Decoder decoder = new BASE64Decoder();
	        //Base64解码
	        byte[] b = decoder.decodeBuffer(imgStr);
	        for(int i=0;i<b.length;++i)
	        {
	            if(b[i]<0)
	            {//调整异常数据
	               b[i]+=256;
	            }
	        }
	        //生成jpeg图片
	        OutputStream out = new FileOutputStream(imgFilePath);
	        out.write(b,0,b.length);
	        out.flush();
	        out.close();
	        return true;
        }
        catch (Exception e)
        {
            return false;
        }
    } 


    /**
     * 图片转化成 base64字符串
     * @param imgStr
     * @return
     * @throws IOException
     */
    public static String ImageConverteStr(String imgStr) throws IOException
    { //对字节数组字符串进行Base64解码并生成图片
        if (imgStr == null) {
        	return "";//图像数据为空
        }
        String str ="";
        try{
        	 BASE64Encoder encoder = new BASE64Encoder();
             FileInputStream inputStream = new FileInputStream(new File(imgStr));
             ByteArrayOutputStream output = new ByteArrayOutputStream();
             byte[] by = new byte[1024];
             int len = 0;
             while((len=inputStream.read(by))!=-1){
                  output.write(by, 0, len);
             }
             output.flush();
             output.close(); 
             str = encoder.encode(output.toByteArray());
        }catch(Exception e){
        	e.printStackTrace();
        }
        return str;
    } 
}
